package com.shuang.graph7;

import java.util.*;
 
//dfs 先对岛屿编号标记 在遍历遇到每个海洋将其变成1 再找其和哪个编号岛屿能组成最大面积
public class Main {
 
    // 定义全局变量
    // 记录每次每个岛屿的面积
    static int count;
    // 对每个岛屿进行标记
    static int mark;
    // 定义二维数组表示四个方位
    static int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
 
    public static void main(String[] args) {
        // 接收输入
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
 
        int[][] grid = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                grid[i][j] = sc.nextInt();
            }
        }
 
        // 初始化mark变量，从2开始（区别于0水，1岛屿）
        mark = 2;
 
        // 定义二位boolean数组记录该位置是否被访问
        boolean[][] visited = new boolean[m][n];
 
        // 定义一个HashMap，记录某片岛屿的标记号和面积
        HashMap<Integer, Integer> getSize = new HashMap<>();
 
        // 定义一个HashSet，用来判断某一位置水四周是否存在不同标记编号的岛屿
        HashSet<Integer> set = new HashSet<>();
 
        // 定义一个boolean变量，看看DFS之后，是否全是岛屿
        boolean isAllIsland = true;
 
        // 遍历二维数组进行DFS搜索，对每片岛屿进行编号和记录对应的面积
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0) isAllIsland = false;
                if (grid[i][j] == 1) {
                    count = 0;
                    dfs(grid, i, j, visited);
                    getSize.put(mark, count);
                    mark++;
                }
            }
        }
 
        //保存结果
        int result = 0;
        //全是岛屿情况
        if (isAllIsland) result = m * n;
 
        // 对标记完的grid继续遍历，判断每个水位置四周是否有岛屿，并记录下四周不同相邻岛屿面积之和
        // 每次计算完一个水位置周围可能存在的岛屿面积之和，更新下result变量
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0) {
                    set.clear();
                    // 当前水位置变更为岛屿，所以初始化为1
                    int curSize = 1;
 
                    for (int[] dir : dirs) {
                        int curRow = i + dir[0];
                        int curCol = j + dir[1];
 
                        if (curRow < 0 || curRow >= m || curCol < 0 || curCol >= n) continue;
                        int curMark = grid[curRow][curCol];
                        // 如果当前相邻的岛屿已经遍历过或者HashMap中不存在这个编号，继续搜索
                        if (set.contains(curMark) || !getSize.containsKey(curMark)) continue;
                        set.add(curMark);
                        curSize += getSize.get(curMark);
                    }
 
                    //计算结果
                    result = Math.max(result, curSize);
                }
            }
        }
        // 打印结果
        System.out.println(result);
    }
 
    //深搜寻找陆地相连 计算每个岛屿面积
    public static void dfs(int[][] grid, int x, int y, boolean[][] visited) {
 
        //终止
        if (grid[x][y] == 0 || visited[x][y]) {
            return;
        }
 
        //标记访问 陆地加一
        visited[x][y] = true;
        count++;
 
        //岛屿做记号
        grid[x][y] = mark;
 
        //四个方向
        for (int i = 0; i < 4; i++) {
            int nextX = x + dirs[i][0];
            int nextY = y + dirs[i][1];
 
            // 当遇到边界
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }
 
            dfs(grid, nextX, nextY, visited);
        }
    }
}